1,364 research outputs found
Variadic genericity through linguistic reflection : a performance evaluation
This work is partially supported by the EPSRC through Grant GR/L32699 “Compliant System Architecture” and by ESPRIT through Working Group EP22552 “PASTEL”.The use of variadic genericity within schema definitions increases the variety of databases that may be captured by a single specification. For example, a class of databases of engineering part objects, in which each database instance varies in the types of the parts and the number of part types, should lend itself to a single definition. However, precise specification of such a schema is beyond the capability of polymorphic type systems and schema definition languages. It is possible to capture such generality by introducing a level of interpretation, in which the variation in types and in the number of fields is encoded in a general data structure. Queries that interpret the encoded information can be written against this general data structure. An alternative approach to supporting such variadic genericity is to generate a precise database containing tailored data structures and queries for each different instance of the virtual schema.1 This involves source code generation and dynamic compilation, a process known as linguistic reflection. The motivation is that once generated, the specific queries may execute more efficiently than their generic counter-parts, since the generic code is “compiled away”. This paper compares the two approaches and gives performance measurements for an example using the persistent languages Napier88 and PJama.Postprin
Hosting Byzantine Fault Tolerant Services on a Chord Ring
In this paper we demonstrate how stateful Byzantine Fault Tolerant services
may be hosted on a Chord ring. The strategy presented is fourfold: firstly a
replication scheme that dissociates the maintenance of replicated service state
from ring recovery is developed. Secondly, clients of the ring based services
are made replication aware. Thirdly, a consensus protocol is introduced that
supports the serialization of updates. Finally Byzantine fault tolerant
replication protocols are developed that ensure the integrity of service data
hosted on the ring.Comment: Submitted to DSN 2007 Workshop on Architecting Dependable System
A Middleware Framework for Constraint-Based Deployment and Autonomic Management of Distributed Applications
We propose a middleware framework for deployment and subsequent autonomic
management of component-based distributed applications. An initial deployment
goal is specified using a declarative constraint language, expressing
constraints over aspects such as component-host mappings and component
interconnection topology. A constraint solver is used to find a configuration
that satisfies the goal, and the configuration is deployed automatically. The
deployed application is instrumented to allow subsequent autonomic management.
If, during execution, the manager detects that the original goal is no longer
being met, the satisfy/deploy process can be repeated automatically in order to
generate a revised deployment that does meet the goal.Comment: Submitted to Middleware 0
A Framework for Constraint-Based Deployment and Autonomic Management of Distributed Applications
We propose a framework for deployment and subsequent autonomic management of
component-based distributed applications. An initial deployment goal is
specified using a declarative constraint language, expressing constraints over
aspects such as component-host mappings and component interconnection topology.
A constraint solver is used to find a configuration that satisfies the goal,
and the configuration is deployed automatically. The deployed application is
instrumented to allow subsequent autonomic management. If, during execution,
the manager detects that the original goal is no longer being met, the
satisfy/deploy process can be repeated automatically in order to generate a
revised deployment that does meet the goal.Comment: Submitted to ICAC-0
Autonomic Management of Maintenance Scheduling in Chord
This paper experimentally evaluates the effects of applying autonomic
management to the scheduling of maintenance operations in a deployed Chord
network, for various membership churn and workload patterns. Two versions of an
autonomic management policy were compared with a static configuration. The
autonomic policies varied with respect to the aggressiveness with which they
responded to peer access error rates and to wasted maintenance operations. In
most experiments, significant improvements due to autonomic management were
observed in the performance of routing operations and the quantity of data
transmitted between network members. Of the autonomic policies, the more
aggressive version gave slightly better results
H2O: An Autonomic, Resource-Aware Distributed Database System
This paper presents the design of an autonomic, resource-aware distributed
database which enables data to be backed up and shared without complex manual
administration. The database, H2O, is designed to make use of unused resources
on workstation machines. Creating and maintaining highly-available, replicated
database systems can be difficult for untrained users, and costly for IT
departments. H2O reduces the need for manual administration by autonomically
replicating data and load-balancing across machines in an enterprise.
Provisioning hardware to run a database system can be unnecessarily costly as
most organizations already possess large quantities of idle resources in
workstation machines. H2O is designed to utilize this unused capacity by using
resource availability information to place data and plan queries over
workstation machines that are already being used for other tasks. This paper
discusses the requirements for such a system and presents the design and
implementation of H2O.Comment: Presented at SICSA PhD Conference 2010 (http://www.sicsaconf.org/
Applying constraint solving to the management of distributed applications
Submitted to DOA08We present our approach for deploying and managing distributed component-based applications. A Desired State Description (DSD), written in a high-level declarative language, specifies requirements for a distributed application. Our infrastructure accepts a DSD as input, and from it automatically configures and deploys the distributed application. Subsequent violations of the original requirements are detected and, where possible, automatically rectified by reconfiguration and redeployment of the necessary application components. A constraint solving tool is used to plan deployments that meet the application requirements.Postprin
A Peer-to-Peer Middleware Framework for Resilient Persistent Programming
The persistent programming systems of the 1980s offered a programming model
that integrated computation and long-term storage. In these systems, reliable
applications could be engineered without requiring the programmer to write
translation code to manage the transfer of data to and from non-volatile
storage. More importantly, it simplified the programmer's conceptual model of
an application, and avoided the many coherency problems that result from
multiple cached copies of the same information. Although technically
innovative, persistent languages were not widely adopted, perhaps due in part
to their closed-world model. Each persistent store was located on a single
host, and there were no flexible mechanisms for communication or transfer of
data between separate stores. Here we re-open the work on persistence and
combine it with modern peer-to-peer techniques in order to provide support for
orthogonal persistence in resilient and potentially long-running distributed
applications. Our vision is of an infrastructure within which an application
can be developed and distributed with minimal modification, whereupon the
application becomes resilient to certain failure modes. If a node, or the
connection to it, fails during execution of the application, the objects are
re-instantiated from distributed replicas, without their reference holders
being aware of the failure. Furthermore, we believe that this can be achieved
within a spectrum of application programmer intervention, ranging from minimal
to totally prescriptive, as desired. The same mechanisms encompass an
orthogonally persistent programming model. We outline our approach to
implementing this vision, and describe current progress.Comment: Submitted to EuroSys 200
A Generic Storage API
We present a generic API suitable for provision of highly generic storage
facilities that can be tailored to produce various individually customised
storage infrastructures. The paper identifies a candidate set of minimal
storage system building blocks, which are sufficiently simple to avoid
encapsulating policy where it cannot be customised by applications, and
composable to build highly flexible storage architectures. Four main generic
components are defined: the store, the namer, the caster and the interpreter.
It is hypothesised that these are sufficiently general that they could act as
building blocks for any information storage and retrieval system. The essential
characteristics of each are defined by an interface, which may be implemented
by multiple implementing classes.Comment: Submitted to ACSC 200
Report on the XBase Project
This project addressed the conceptual fundamentals of data storage,
investigating techniques for provision of highly generic storage facilities
that can be tailored to produce various individually customised storage
infrastructures, compliant to the needs of particular applications. This
requires the separation of mechanism and policy wherever possible. Aspirations
include: actors, whether users or individual processes, should be able to bind
to, update and manipulate data and programs transparently with respect to their
respective locations; programs should be expressed independently of the storage
and network technology involved in their execution; storage facilities should
be structure-neutral so that actors can impose multiple interpretations over
information, simultaneously and safely; information should not be discarded so
that arbitrary historical views are supported; raw stored information should be
open to all; where security restrictions on its use are required this should be
achieved using cryptographic techniques. The key advances of the research were:
1) the identification of a candidate set of minimal storage system building
blocks, which are sufficiently simple to avoid encapsulating policy where it
cannot be customised by applications, and composable to build highly flexible
storage architectures 2) insight into the nature of append-only storage
components, and the issues arising from their application to common storage
use-cases
- …